package dict

import (
	"fmt"
	"sort"

	"codeup.aliyun.com/lsxd/zltx/adapter/utils/sortx/order"
)

// KeyValue 键值对
type KeyValue struct {
	Key   string
	Value any
}

// ValueEncoder 值编码器
type ValueEncoder func(s []byte) ([]byte, error)

func (kv *KeyValue) ValueString(valueEncoder ValueEncoder) string {
	valStr := fmt.Sprintf("%v", kv.Value)
	if valueEncoder != nil {
		if encodedValue, err := valueEncoder([]byte(valStr)); err == nil {
			valStr = string(encodedValue)
		} else {
			//todo 编码转换失败
		}
	}
	return valStr
}

// Dict 字典
type Dict struct {
	kvs []KeyValue
}

// NewDict 创建字典
func NewDict(kvs ...KeyValue) *Dict {
	return &Dict{kvs: kvs}
}

// Add 添加键值对
func (p *Dict) Add(key string, value any) {
	p.kvs = append(p.kvs, KeyValue{key, value})
}

// Adds 添加键值对
func (p *Dict) Adds(kvs ...KeyValue) {
	p.kvs = append(p.kvs, kvs...)
}

// List 字典列表
func (p *Dict) List() []KeyValue {
	return p.kvs
}

// Sort 字典排序，默认升序，可指定 order 参数为 "desc" 降序.
func (p *Dict) Sort(o order.Order) *Dict {
	switch o {
	case order.Desc:
		sort.Slice(p.kvs, func(i, j int) bool {
			return p.kvs[i].Key > p.kvs[j].Key
		})
	case order.Aes:
		sort.Slice(p.kvs, func(i, j int) bool {
			return p.kvs[i].Key < p.kvs[j].Key
		})
	case order.None:
	default:
		//不做任何排序处理
	}

	return p
}

// FixedSort 固定排序，根据传入的排序映射进行排序.
func (p *Dict) FixedSort(sortMap map[string]int) *Dict {
	// 清理不在排序映射中的键值对
	for i := len(p.kvs) - 1; i >= 0; i-- {
		if _, ok := sortMap[p.kvs[i].Key]; !ok {
			p.kvs = append(p.kvs[:i], p.kvs[i+1:]...)
		}
	}

	// 使用sort.Slice函数进行排序
	sort.Slice(p.kvs, func(i, j int) bool {
		return sortMap[p.kvs[i].Key] <= sortMap[p.kvs[j].Key]
	})
	return p
}
